package com.sumainfor.pc.gmio.service.impl;

import com.baomidou.mybatisplus.generator.config.IFileCreate;
import com.sumainfor.common.Constants;
import com.sumainfor.common.util.ContextUtils;
import com.sumainfor.common.util.JsonResult;
import com.sumainfor.common.utlis.ComUtils;
import com.sumainfor.common.utlis.CompuUtils;
import com.sumainfor.common.utlis.ParamsCommon;
import com.sumainfor.pc.gmio.dao.*;
import com.sumainfor.pc.gmio.feign.Zfeign.ZpcMktFeign;
import com.sumainfor.pc.gmio.service.HoTenantExtService;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.math.DoubleRange;
import org.omg.CORBA.OBJ_ADAPTER;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.SimpleFormatter;

/**
 * @author zc
 * @ClassName HoTenantExtServiceImpl
 * @date 2019/11/18 11:02
 * @description: TODO
 */
@Service
public class HoTenantExtServiceImpl implements HoTenantExtService {
    private ReentrantLock lock = new ReentrantLock(false);
    Logger log = LoggerFactory.getLogger(HoTenantExtServiceImpl.class);

    @Autowired
    UtilsMapper utilsMapper;
    @Autowired
    ZpcMktFeign zpcMktFeign;
    @Autowired
    HoEleMeterMapper hoEleMeterMapper;
    @Autowired
    HoWaterMeterMapper hoWaterMeterMapper;
    @Autowired
    HoGasMeterMapper hoGasMeterMapper;

    @Autowired
    HoPooledMapper hoPooledMapper;

    /**
     * 租赁顾问签约抄水电煤
     * @param params
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JsonResult addHoWegMeterExt(Map<String, Object> params) {
        JsonResult result = new JsonResult();

        /**
         * 加锁操作
         */
        lock.lock();
        try {
            //水电燃记录编号
            String EleUUID = "";//电抄表编号
            String EleUUIDS = "";//公摊电抄表编号
            String WatUUID = "";//水抄表编号
          //  String WatUUIDS="";//公摊水抄表编号
            String GasUUID = "";//燃抄表编号
            //水电燃批次记录编号
            String Eleus = "";//电抄表批次编号
            String Watus = "";//水抄表批次编号
            String Gasus = "";//燃抄表批次编号

            //电
            Map<String,Object>Eleuuid=utilsMapper.getUUID(new HashMap<String,Object>(){{
                put("uuid", "ElemeId");
                put("database", Constants.DATA_SOURCE_GMIO);
                put("surface", "tcgmio_ele_meter");
            }});
//            //公摊电
//            Map<String,Object>Eleuuidss=utilsMapper.getUUID(new HashMap<String,Object>(){{
//                put("uuid", "ElePooledId");
//                put("database", Constants.DATA_SOURCE_GMIO);
//                put("surface", "tcgmio_ele_meter_Pooled");
//            }});
            //水
            Map<String,Object>Watuuid=utilsMapper.getUUID(new HashMap<String,Object>(){{
                put("uuid", "WameId");
                put("database", Constants.DATA_SOURCE_GMIO);
                put("surface", "tcgmio_water_meter");
            }});
//            //公摊水
//            Map<String,Object>Watuuidss=utilsMapper.getUUID(new HashMap<String,Object>(){{
//                put("uuid", "WatPooledId");
//                put("database", Constants.DATA_SOURCE_GMIO);
//                put("surface", "tcgmio_water_meter_Pooled");
//            }});
            //燃
            Map<String,Object>Gasuuid=utilsMapper.getUUID(new HashMap<String,Object>(){{
                put("uuid", "GasmeId");
                put("database", Constants.DATA_SOURCE_GMIO);
                put("surface", "tcgmio_gas_meter");
            }});

//        参数格式
//                params:{
//                            "HouId":"签约时的房源号",
//                            "HouInfoId":"签约时的房源详表编号",
//                            "EleData":{
//                                "LastMonthEleSum":"上月总",
//                                "LastMonthElePeak":"上月峰",
//                                "LastMonthEleFlat":"上月谷",
//                                "ThisMonthEleSum":"本次总",
//                                "ThisMonthElePeak":"本次峰",
//                                "ThisMonthEleFlat":"本次谷",
//                                "roomData":[
//                            {
//                            "LastMonthEleSum":"房间上月总",
//                            "ThisMonthEleSum":"房间本次总"
//                            "HouInfoId":"房源详表编号"
//                        }
//
//			]
//
//                    },
//                    "WatData":{
//                        "LastMonthRead":"上次总表数",
//                        "ThisMonthRead":"本次总表数"
//                    },
//                    "GasData":{
//                        "LastMonthRead":"上次总表数",
//                        "ThisMonthRead":"本次总表数"
//                    }
//
//                }



            Date nowTime = new Date();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String GenerateTime = sdf.format(nowTime);//租赁顾问签约抄水电燃,抄表记录的时间默认一致
            int zhengzuCount = 0;//整租需要操作增加的抄表数
            int  HeZuCount = 0;//合租需要操作增加的抄表数
            Map<String,Object> EleData = (Map<String, Object>) params.get("EleData");//电表
            Map<String,Object> WatData = (Map<String, Object>)params.get("WatData");//水表
            Map<String,Object> GasData = (Map<String, Object>)params.get("GasData");//燃气表
            List<Map<String, Object>> getHouInfoNumList = zpcMktFeign.getHouInfoNum(params);//获取当前房源下的所有房间
            String HouInfoIds = MapUtils.getString(params,"HouInfoId");//本次签约的房间
            List<Map<String,Object>> getHouPactList = zpcMktFeign.getHouPact(params);//查询当前房源下所有在租合同
            JsonResult  getHouInfoPaymentResult = zpcMktFeign.getHouInfoPayment(params);//查询当前房源是否存在智能电表
            Map<String,Object> getHouInfoMap = (Map<String, Object>) getHouInfoPaymentResult.get("result");
            Integer Payment = MapUtils.getInteger(getHouInfoMap,"Payment");//0智能1非智能
            if(HouInfoIds.substring(HouInfoIds.length()-1,HouInfoIds.length()).equals("Z")){//房源出租类型为整租

                    if (MapUtils.getInteger(getHouInfoMap,"Payment")==0){//整租智能
                        //修改电表模式










                    }
                    //记录水抄表,不生成账单
                    Map<String,Object> WatMap = new HashMap<>();//记录水
                    if(Watuuid!=null){
                        int number=Integer.valueOf(Watuuid.get("uuid").toString());
                        WatUUID= ComUtils.getLocalTrmSeqNum("WM0",number);
                        Watus = ComUtils.getLocalTrmSeqNum("BA0",number);
                    }else{
                        WatUUID=ComUtils.getLocalTrmSeqNum("WM0",0);
                        Watus = ComUtils.getLocalTrmSeqNum("BA0",0);
                    }
                    WatMap.put("term", "2");//创建端  1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
                    WatMap.put("fnc",
                            this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                    ParamsCommon.commonInsertParms(WatMap);
                    WatMap.put("WameId",WatUUID);//水费抄表编号
                    WatMap.put("BatchId",Watus);//批次编号
                    WatMap.put("HouId",params.get("HouId"));//房源编号
                    WatMap.put("HouInfoId",params.get("HouInfoId"));//房源详表编号
                    WatMap.put("IfOperaType",1);//是否整租0否1是
                    WatMap.put("LastMonthRead",WatData.get("LastMonthRead"));//上次总表数
                    WatMap.put("ThisMonthRead",WatData.get("ThisMonthRead"));//总表数
                    WatMap.put("GenerateTime",GenerateTime);//抄表日期
                    WatMap.put("Recorder", ContextUtils.getUserId());//记录人编号
                    WatMap.put("IfApportion",0);//是否需要分摊0否1是
                    Integer a1 = hoWaterMeterMapper.addHoWaterMeter(WatMap);//增加水抄表记录
                if (a1>0){
                    zhengzuCount++;
                    //result.putSuccess("新增水表成功");
                }else{
                    result.putFailed("新增水表失败");
                }



                    Map<String,Object> EleMap = new HashMap<>();//记录电不生成账单
                    if(Eleuuid!=null){
                        int number=Integer.valueOf(Eleuuid.get("uuid").toString());
                        EleUUID= ComUtils.getLocalTrmSeqNum("EM0",number);
                        Eleus = ComUtils.getLocalTrmSeqNum("BA0",number);
                    }else{
                        EleUUID=ComUtils.getLocalTrmSeqNum("EM0",0);
                        Eleus = ComUtils.getLocalTrmSeqNum("BA0",0);
                    }
                    EleMap.put("term", "2");//创建端  1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
                    EleMap.put("fnc",
                            this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                    ParamsCommon.commonInsertParms(EleMap);
                    EleMap.put("ElemeId",EleUUID);//电费抄表编号
                    EleMap.put("BatchId",Eleus);//批次编号
                    EleMap.put("HouId",params.get("HouId"));//房源编号
                    EleMap.put("HouInfoId",params.get("HouInfoId"));//房源详表编号
                    EleMap.put("IfOperaType",1);//是否整租0否1是
                    EleMap.put("LastMonthEleSum",EleData.get("LastMonthEleSum"));//上次总表
                    EleMap.put("LastMonthElePeak",EleData.get("LastMonthElePeak"));//上次峰表
                    EleMap.put("LastMonthEleFlat",EleData.get("LastMonthEleFlat"));//上次谷表
                    EleMap.put("ThisMonthEleSum",EleData.get("ThisMonthEleSum"));//总表
                    EleMap.put("ThisMonthElePeak",EleData.get("ThisMonthElePeak"));//峰表
                    EleMap.put("ThisMonthEleFlat",EleData.get("ThisMonthEleFlat"));//谷表
                    //EleMap.put("perELeSum",0);//房间均摊电量
                    EleMap.put("GenerateTime",GenerateTime);//抄表日期
                    EleMap.put("Recorder", ContextUtils.getUserId());//记录人编号
                    EleMap.put("IfApportion",0);//是否需要分摊0否1是
                    EleMap.put("IfGenerate",0);//是否生成账单0未生成 1已生成
                    Integer a2 = hoEleMeterMapper.addHoEleMeter(EleMap);//新增电抄表记录
                     if (a2>0){
                         zhengzuCount++;
                         //result.putSuccess("新增电表成功");
                     }else{
                         result.putFailed("新增电表失败");
                     }

                 Map<String,Object> GasMap = new HashMap<>();//记录燃不生成账单
                    if(Gasuuid!=null){
                        int number=Integer.valueOf(Gasuuid.get("uuid").toString());
                        GasUUID= ComUtils.getLocalTrmSeqNum("WM0",number);
                        Gasus = ComUtils.getLocalTrmSeqNum("BA0",number);
                    }else{
                        GasUUID=ComUtils.getLocalTrmSeqNum("WM0",0);
                        Gasus = ComUtils.getLocalTrmSeqNum("BA0",0);
                    }
                    GasMap.put("term", "2");//创建端  1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
                    GasMap.put("fnc",
                            this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                    ParamsCommon.commonInsertParms(GasMap);
                    GasMap.put("GasmeId",GasUUID);//燃气费抄表编号
                    GasMap.put("BatchId",Gasus);//批次编号
                    GasMap.put("HouId",params.get("HouId"));//房源编号
                    GasMap.put("HouInfoId",params.get("HouInfoId"));//房源详表编号
                    GasMap.put("IfOperaType",1);//是否整租0否1是
                    GasMap.put("LastMonthRead",GasData.get("LastMonthRead"));//上次总表数
                    GasMap.put("ThisMonthRead",GasData.get("ThisMonthRead"));//总表数
                    GasMap.put("GenerateTime",GenerateTime);//抄表日期
                    GasMap.put("Recorder", ContextUtils.getUserId());//记录人编号
                    GasMap.put("IfApportion",0);//是否需要分摊0否1是
                    Integer a3= hoGasMeterMapper.addHoGasMeter(GasMap);//新增燃气抄表记录
                   if (a3>0){
                       //result.putSuccess("新增燃气表成功");
                       zhengzuCount++;
                   }else{
                       result.putFailed("新增燃气表失败");
                   }


            }else {
                //表示合租的房子标识房间有ABZ等,并且房间不是Z
                //水费燃气费只需要记录整租的,电费则需要记录到房间
                //先生成一个批次编号,该房源下的记录抄表数均用当前这个批次编号
                //假设批次编号已经生成BatchId,在算出当前抄表时,该房源下的租客的均摊电量
                //Map<String,Object> EleData = (Map<String, Object>) params.get("EleData");//电抄表集合
                List<Map<String, Object>> roomData = (List<Map<String, Object>>) EleData.get("roomData");//房间电抄表集合

                double LastMonthEleSumRoom = 0; //上次房间总抄表
                double ThisMonthEleSumRoom = 0;//本次房间总抄表
                double LastMonthEleSumAlls = MapUtils.getDouble(EleData, "LastMonthEleSum");//上月总表
                double ThisMonthEleSumAlls = MapUtils.getDouble(EleData, "ThisMonthEleSum");//本次总表
                for (Map<String, Object> roomDatMap : roomData) {
                    LastMonthEleSumRoom = CompuUtils.add(LastMonthEleSumRoom, MapUtils.getDouble(roomDatMap, "LastMonthEleSum"));
                    ThisMonthEleSumRoom = CompuUtils.add(ThisMonthEleSumRoom, MapUtils.getDouble(roomDatMap, "ThisMonthEleSum"));
                }
                //签约时在租房间的均摊总电量
                double PoolSum = CompuUtils.reduce(CompuUtils.reduce(ThisMonthEleSumAlls, ThisMonthEleSumRoom), CompuUtils.reduce(LastMonthEleSumAlls, LastMonthEleSumRoom));


                //每个在租房间的均摊量
                double ElePool = 0;
                if(getHouPactList.size()>0){
                     ElePool = CompuUtils.div(PoolSum, getHouPactList.size());
                }

                //先记录批次编号,然后走循环,本次记录电表的各个房间的批次编号相同
                int numbers = 0;
                if (Eleuuid != null) {
                    numbers = Integer.valueOf(Eleuuid.get("uuid").toString());
                    Eleus = ComUtils.getLocalTrmSeqNum("BA0", numbers);

                } else {
                    Eleus = ComUtils.getLocalTrmSeqNum("BA0", 0);
                }

                Map<String, Object> EleMap = new HashMap<>();//记录电

                EleMap.put("term", "2");//创建端  1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
                EleMap.put("fnc",
                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                ParamsCommon.commonInsertParms(EleMap);
                EleMap.put("ElemeId", ComUtils.getLocalTrmSeqNum("EM" + 0, numbers));//电费抄表编号(公共区域)
                EleMap.put("BatchId", Eleus);//批次编号
                EleMap.put("HouId", params.get("HouId"));//房源编号
                String a = MapUtils.getString(params, "HouInfoId");
                EleMap.put("HouInfoId", a.replace(a.substring(a.length() - 1, a.length()), "Z"));//公共区域的房源详表编号
                EleMap.put("IfOperaType", 1);//是否整租0否1是
                EleMap.put("LastMonthEleSum", EleData.get("LastMonthEleSum"));//上次总表
                //EleMap.put("LastMonthElePeak", EleData.get("LastMonthElePeak"));//上次峰表
               // EleMap.put("LastMonthEleFlat", EleData.get("LastMonthEleFlat"));//上次谷表
                EleMap.put("ThisMonthEleSum", EleData.get("ThisMonthEleSum"));//总表
                //EleMap.put("ThisMonthElePeak", EleData.get("ThisMonthElePeak"));//峰表
               // EleMap.put("ThisMonthEleFlat", EleData.get("ThisMonthEleFlat"));//谷表
                EleMap.put("GenerateTime", GenerateTime);//抄表日期
                EleMap.put("Recorder", ContextUtils.getUserId());//记录人编号
                EleMap.put("IfGenerate", 0);//是否生成账单0未生成 1已生成
                if(Payment==1){ //非智能
                    EleMap.put("perELeSum", PoolSum);//公共区域均摊电量
                    if(getHouPactList.size()>0){//表示签约时当前房源的其他房间出租

                        EleMap.put("IfApportion", 1);//是否需要分摊0否1是
                        Integer a4 = hoEleMeterMapper.addHoEleMeter(EleMap);//新增公共区域电抄表记录
                        if (a4 > 0) {
                            HeZuCount++;
                            // result.putSuccess("新增公共区域抄表成功");
                        } else {
                            result.putFailed("新增公共区域抄表失败");
                        }

                    }else {//签约时当前房源的其他房间均未出租

                        EleMap.put("IfApportion", 0);//是否需要分摊0否1是
                        Integer a4 = hoEleMeterMapper.addHoEleMeter(EleMap);//新增公共区域电抄表记录
                        if (a4 > 0) {
                            HeZuCount++;
                            // result.putSuccess("新增公共区域抄表成功");
                        } else {
                            result.putFailed("新增公共区域抄表失败");
                        }

                    }
                    }

//                }else{//智能
//                    EleMap.put("IfApportion", 0);//是否需要分摊0否1是
//                    Integer a44 = hoEleMeterMapper.addHoEleMeter(EleMap);//新增公共区域电抄表记录
//                    if (a44 > 0) {
//                        HeZuCount++;
//                        // result.putSuccess("新增公共区域抄表成功");
//                    } else {
//                        result.putFailed("新增公共区域抄表失败");
//                    }
//
//                }

                if (getHouPactList.size()<1){//表示签约时当前方源无其他房间出租,不用管智能还是非智能,都不会均摊

                    if (Payment==1) {//合租非智能抄房间表
                        for (int i = 0; i < roomData.size(); i++) {
                            Map<String, Object> MapEle = new HashMap<>();//记录房间电抄表记录
                            MapEle.put("term", "2");//创建端  1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
                            MapEle.put("fnc",
                                    this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                            ParamsCommon.commonInsertParms(MapEle);
                            MapEle.put("ElemeId", ComUtils.getLocalTrmSeqNum("EM" + (i + 1), numbers));//电费抄表编号(公共区域)
                            MapEle.put("BatchId", Eleus);//批次编号
                            MapEle.put("HouId", params.get("HouId"));//房源编号
                            MapEle.put("HouInfoId", roomData.get(i).get("HouInfoId"));//房间的房源详表编号
                            MapEle.put("IfOperaType", 0);//是否整租0否1是
                            MapEle.put("LastMonthEleSum", roomData.get(i).get("LastMonthEleSum"));//上次总表
                            MapEle.put("ThisMonthEleSum", roomData.get(i).get("ThisMonthEleSum"));//总表
                            MapEle.put("GenerateTime", GenerateTime);//抄表日期
                            MapEle.put("Recorder", ContextUtils.getUserId());//记录人编号
                            MapEle.put("IfGenerate", 0);//是否生成账单0未生成
                            MapEle.put("IfApportion", 0);//是否需要分摊0否1是
                            Integer a5 = hoEleMeterMapper.addHoEleMeter(MapEle);//新增其他房间电抄表记录
                            if (a5 > 0) {
                                // result.putSuccess("新增房间抄表成功");
                                HeZuCount++;
                            } else {
                                result.putFailed("新增房间抄表失败");
                            }

                        }

                    }



                }else{//表示签约的时候当前房源的其他房间有出租,需要记录出租房源的均摊量




//
//                    if (Payment ==0){//表示智能,合租智能,且当前房源的其他房间有出租,那只用记录抄表,不用均摊
//                        for (int i = 0; i < roomData.size(); i++) {
//                            Map<String, Object> MapEle = new HashMap<>();//记录房间电抄表记录
//                            MapEle.put("term", "2");//创建端  1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
//                            MapEle.put("fnc",
//                                    this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
//                            ParamsCommon.commonInsertParms(MapEle);
//                            MapEle.put("ElemeId", ComUtils.getLocalTrmSeqNum("EM" + (i + 1), numbers));//电费抄表编号(公共区域)
//                            MapEle.put("BatchId", Eleus);//批次编号
//                            MapEle.put("HouId", params.get("HouId"));//房源编号
//                            MapEle.put("HouInfoId", roomData.get(i).get("HouInfoId"));//房间的房源详表编号
//                            MapEle.put("IfOperaType", 0);//是否整租0否1是
//                            MapEle.put("LastMonthEleSum", roomData.get(i).get("LastMonthEleSum"));//上次总表
//                            MapEle.put("ThisMonthEleSum", roomData.get(i).get("ThisMonthEleSum"));//总表
//                            MapEle.put("GenerateTime", MapEle.get("instm"));//抄表日期
//                            MapEle.put("Recorder", ContextUtils.getUserId());//记录人编号
//                            MapEle.put("IfGenerate", 0);//是否生成账单0未生成 1已生成
//                            MapEle.put("IfApportion", 0);//是否需要分摊0否1是
//                            Integer a5 = hoEleMeterMapper.addHoEleMeter(MapEle);//新增其他房间电抄表记录
//                            if (a5 > 0) {
//                                // result.putSuccess("新增房间抄表成功");
//                                HeZuCount++;
//                            } else {
//                                result.putFailed("新增房间抄表失败");
//                            }
//
//                        }
//
//                    }else {//表示非智能,合租非智能.且当前房源的其他房间有出租,那么不但需要记录,还需要均摊已出租房源
                    if (Payment==1){//表示非智能,合租非智能.且当前房源的其他房间有出租,那么不但需要记录,还需要均摊已出租房源
                        for (int i = 0; i < roomData.size(); i++) {
                            Map<String, Object> MapEle = new HashMap<>();//记录房间电抄表记录
                            MapEle.put("term", "2");//创建端  1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
                            MapEle.put("fnc",
                                    this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                            ParamsCommon.commonInsertParms(MapEle);
                            MapEle.put("ElemeId", ComUtils.getLocalTrmSeqNum("EM" + (i + 1), numbers));//电费抄表编号(公共区域)
                            MapEle.put("BatchId", Eleus);//批次编号
                            MapEle.put("HouId", params.get("HouId"));//房源编号
                            MapEle.put("HouInfoId", roomData.get(i).get("HouInfoId"));//房间的房源详表编号
                            MapEle.put("IfOperaType", 0);//是否整租0否1是
                            MapEle.put("LastMonthEleSum",  roomData.get(i).get("LastMonthEleSum"));//上次总表
                            MapEle.put("ThisMonthEleSum",  roomData.get(i).get("ThisMonthEleSum"));//总表
                            MapEle.put("GenerateTime", GenerateTime);//抄表日期
                            MapEle.put("Recorder", ContextUtils.getUserId());//记录人编号
                            MapEle.put("IfGenerate", 0);//是否生成账单0未生成 1已生成
                            MapEle.put("IfApportion", 0);//是否需要分摊0否1是
                            String HouInfossss = roomData.get(i).get("HouInfoId").toString();
                            for (Map<String,Object> map1:getHouPactList) {
                                if(HouInfossss.equals(MapUtils.getString(map1,"HouInfoId"))){
                                    MapEle.put("IfApportion", 1);//是否需要分摊0否1是
                                    //总的均摊量
                                    Double perEleSum = CompuUtils.add(ElePool,CompuUtils.reduce(MapUtils.getDouble(MapEle,"ThisMonthEleSum"),MapUtils.getDouble(MapEle,"LastMonthEleSum")));
                                     MapEle.put("perELeSum", perEleSum);//房间均摊电量
                                    MapEle.put("perELeMoney",CompuUtils.mul(MapUtils.getDouble(map1,"EleFee"),perEleSum));//记录在租每个房间的均摊电量金额

//                                    Integer a5 = hoEleMeterMapper.addHoEleMeter(MapEle);//新增其他房间电抄表记录
//                                    if (a5 > 0) {
//                                        // result.putSuccess("新增房间抄表成功");
//                                        HeZuCount++;
//                                    } else {
//                                        result.putFailed("新增房间抄表失败");
//                                    }
                                }
//
                            }
                                Integer a5 = hoEleMeterMapper.addHoEleMeter(MapEle);//新增其他房间电抄表记录
                                if (a5 > 0) {
                                    // result.putSuccess("新增房间抄表成功");
                                    HeZuCount++;
                                } else {
                                    result.putFailed("新增房间抄表失败");
                                }





                        }
                    }
                }

                //记录水费和燃气费
                for (Map<String,Object> map2:getHouInfoNumList) {//循环遍历
                    String HouInfos =MapUtils.getString(map2,"HouInfoId");//房间编号
                    if(HouInfos.substring(HouInfos.length()-1,HouInfos.length()).equals("Z")){//为如果房间号Z记录水费燃气费

           //             if(Payment==0) {


//                        //表示合组智能水费燃气为固定金额,记录抄表数不生成账单
//                        //记录水费
//                        Map<String,Object> WatMap = new HashMap<>();//记录水
//                        if(Watuuid!=null){
//                            int number=Integer.valueOf(Watuuid.get("uuid").toString());
//                            WatUUID= ComUtils.getLocalTrmSeqNum("WM0",number);
//                            Watus = ComUtils.getLocalTrmSeqNum("BA0",number);
//                        }else{
//                            WatUUID=ComUtils.getLocalTrmSeqNum("WM0",0);
//                            Watus = ComUtils.getLocalTrmSeqNum("BA0",0);
//                        }
//                        WatMap.put("term", "2");//创建端  1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
//                        WatMap.put("fnc",
//                                this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
//                        ParamsCommon.commonInsertParms(WatMap);
//                        WatMap.put("WameId",WatUUID);//水费抄表编号
//                        WatMap.put("BatchId",Watus);//批次编号
//                        WatMap.put("HouId",params.get("HouId"));//房源编号
//                        WatMap.put("HouInfoId",map2.get("HouInfoId"));//房源详表编号
//                        WatMap.put("IfOperaType",1);//是否整租0否1是
//                        WatMap.put("LastMonthRead",WatData.get("LastMonthRead"));//上次总表数
//                        WatMap.put("ThisMonthRead",WatData.get("ThisMonthRead"));//总表数
//                        WatMap.put("GenerateTime",WatMap.get("instm"));//抄表日期
//                        WatMap.put("Recorder", ContextUtils.getUserId());//记录人编号
//                        WatMap.put("IfApportion",0);//是否需要分摊0否1是
//                        Integer a6  = hoWaterMeterMapper.addHoWaterMeter(WatMap);//增加水抄表记录
//                            if (a6>0){
//                               // result.putSuccess("新增水抄表成功");
//                                HeZuCount++;
//                            }else{
//                                result.putFailed("新增水抄表失败");
//                            }
//
//                        //记录燃气
//                            Map<String, Object> GasMap = new HashMap<>();//记录燃不生成账单
//                            if (Gasuuid != null) {
//                                int number = Integer.valueOf(Gasuuid.get("uuid").toString());
//                                GasUUID = ComUtils.getLocalTrmSeqNum("WM0", number);
//                                Gasus = ComUtils.getLocalTrmSeqNum("BA0", number);
//                            } else {
//                                GasUUID = ComUtils.getLocalTrmSeqNum("WM0", 0);
//                                Gasus = ComUtils.getLocalTrmSeqNum("BA0", 0);
//                            }
//                            GasMap.put("term", "2");//创建端  1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
//                            GasMap.put("fnc",
//                                    this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
//                            ParamsCommon.commonInsertParms(GasMap);
//                            GasMap.put("GasmeId", GasUUID);//燃气费抄表编号
//                            GasMap.put("BatchId", Gasus);//批次编号
//                            GasMap.put("HouId", params.get("HouId"));//房源编号
//                            GasMap.put("HouInfoId", map2.get("HouInfoId"));//房源详表编号
//                            GasMap.put("IfOperaType", 1);//是否整租0否1是
//                            GasMap.put("LastMonthRead", GasData.get("LastMonthRead"));//上次总表数
//                            GasMap.put("ThisMonthRead", GasData.get("ThisMonthRead"));//总表数
//                            GasMap.put("GenerateTime", GasMap.get("instm"));//抄表日期
//                            GasMap.put("Recorder", ContextUtils.getUserId());//记录人编号
//                            GasMap.put("IfApportion", 0);//是否需要分摊0否1是
//                            Integer a7 = hoGasMeterMapper.addHoGasMeter(GasMap);//新增燃气抄表记录
//                            if (a7>0){
//                               // result.putSuccess("新增燃气抄表成功");
//                                HeZuCount++;
//
//                            }else{
//                                result.putFailed("新增燃气抄表失败");
//                            }

              //          }else{//表示合租非智能水费抄表分摊,燃气没有,水费需要每个房间平分


                            if(Payment==1) {
                                //记录水费
                                Map<String, Object> WatMap = new HashMap<>();//记录水
                                if (Watuuid != null) {
                                    int number = Integer.valueOf(Watuuid.get("uuid").toString());
                                    WatUUID = ComUtils.getLocalTrmSeqNum("WM0", number);
                                    Watus = ComUtils.getLocalTrmSeqNum("BA0", number);
                                } else {
                                    WatUUID = ComUtils.getLocalTrmSeqNum("WM0", 0);
                                    Watus = ComUtils.getLocalTrmSeqNum("BA0", 0);
                                }
                                WatMap.put("term", "2");//创建端  1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
                                WatMap.put("fnc",
                                        this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                                ParamsCommon.commonInsertParms(WatMap);
                                WatMap.put("WameId", WatUUID);//水费抄表编号
                                WatMap.put("BatchId", Watus);//批次编号
                                WatMap.put("HouId", params.get("HouId"));//房源编号
                                WatMap.put("HouInfoId", map2.get("HouInfoId"));//房源详表编号
                                WatMap.put("IfOperaType", 1);//是否整租0否1是
                                WatMap.put("LastMonthRead", WatData.get("LastMonthRead"));//上次总表数
                                WatMap.put("ThisMonthRead", WatData.get("ThisMonthRead"));//总表数
                                WatMap.put("GenerateTime", GenerateTime);//抄表日期
                                WatMap.put("Recorder", ContextUtils.getUserId());//记录人编号
                                if (getHouPactList.size() > 0) {//说明签约时当前房源有出租状态,需要算出出租房源的均摊电量
                                    WatMap.put("IfApportion", 1);//是否需要分摊0否1是
                                    Integer a8 = hoWaterMeterMapper.addHoWaterMeter(WatMap);//增加水抄表记录
                                    if (a8 > 0) {
                                        HeZuCount++;
                                        // result.putSuccess("新增水抄表成功");
                                    } else {
                                        result.putFailed("新增水抄表失败");
                                    }

                                    //计算出均摊水
                                    Double ThisMonthRead = MapUtils.getDouble(WatData, "ThisMonthRead");//总表数
                                    Double LastMonthRead = MapUtils.getDouble(WatData, "LastMonthRead");//上次总表数
                                    Double WatPooleds = CompuUtils.reduce(ThisMonthRead, LastMonthRead);//总的公摊

                                    Double WatPooled = new Double("0");
                                    if (getHouPactList.size() > 0) {//表示当前房源的其他房间有出租的
                                        WatPooled = CompuUtils.div(WatPooleds, new Double(String.valueOf(getHouPactList.size())), 2);//在租房间的均摊用水量
                                    }

                                    for (Map<String, Object> polMAP : getHouPactList) {

                                        //记录公摊水费
                                        Map<String, Object> WatPolMap = new HashMap<>();
                                        String WatUUIDS="";//公摊水抄表编号
                                        //公摊水
                                        Map<String,Object>Watuuidss=utilsMapper.getUUID(new HashMap<String,Object>(){{
                                            put("uuid", "WatPooledId");
                                            put("database", Constants.DATA_SOURCE_GMIO);
                                            put("surface", "tcgmio_water_meter_Pooled");
                                        }});

                                        if (Watuuidss != null) {
                                            int number = Integer.valueOf(Watuuidss.get("uuid").toString());
                                            WatUUIDS = ComUtils.getLocalTrmSeqNum("WP", number);
                                        } else {
                                            WatUUIDS = ComUtils.getLocalTrmSeqNum("WP", 0);
                                        }
                                        WatPolMap.put("term", "2");//创建端  1 租客端 2市场部 3 工程部 4运营部 5财务部 6总经办 7发展部
                                        WatPolMap.put("fnc",
                                                this.getClass().getSimpleName() + "." + Thread.currentThread().getStackTrace()[1].getMethodName());// 创建Function名
                                        ParamsCommon.commonInsertParms(WatPolMap);
                                        WatPolMap.put("WatPooledId", WatUUIDS);//公摊水表编号
                                        WatPolMap.put("WameId", WatMap.get("WameId"));//水抄表编号
                                        WatPolMap.put("BatchId", WatMap.get("BatchId"));//水抄表批次编号
                                        WatPolMap.put("TenId", polMAP.get("TenId"));//租客编号
                                        WatPolMap.put("HouId", polMAP.get("HouId"));//房源编号
                                        WatPolMap.put("HouInfoId", polMAP.get("HouInfoId"));//房源详表编号
                                        WatPolMap.put("WatPooled", WatPooled);//公摊用水量
                                        WatPolMap.put("WatMetMoney",CompuUtils.mul(MapUtils.getDouble(polMAP,"WaterPricing"),WatPooled));//记录在租房间的公摊水费
                                        WatPolMap.put("PoolTime", WatMap.get("GenerateTime"));//公摊生成时间
                                        Integer a9 = hoPooledMapper.addWatPooled(WatPolMap);//循环新增签约时在租房间的均摊用水量
                                        if (a9 > 0) {
                                            HeZuCount++;
                                            // result.putSuccess("新增均摊用水量成功");
                                        } else {
                                            result.putFailed("新增均摊用水量失败");
                                        }
                                    }

                                } else {//说明签约时当前合租房没有房源出租.那么无须记录均摊
                                    WatMap.put("IfApportion", 0);//是否需要分摊0否1是
                                    Integer a10 = hoWaterMeterMapper.addHoWaterMeter(WatMap);//增加水抄表记录
                                    if (a10 > 0) {
                                        HeZuCount++;
                                        //result.putSuccess("新增水抄表记录成功");
                                    } else {
                                        result.putFailed("新增水抄表记录失败");
                                    }
                                }
                            }
                      //  }

                    }

                }
            }

            if(HouInfoIds.substring(HouInfoIds.length()-1,HouInfoIds.length()).equals("Z")){
                if (zhengzuCount==3){
                    result.putSuccess("新增整租抄表数成功");
                }else{
                    result.putFailed("新增整租抄表数失败");
                }

            }else{//合租
//                if(Payment==0){//智能
//                    if(HeZuCount==(getHouInfoNumList.size())){
//                        result.putSuccess("新增合组智能抄表数成功");
//                    }else{
//                        result.putFailed("新增合租智能抄表数失败");
//                    }
//
//                }else{//非智能,水表要均分到房间
                if(Payment==1){//非智能
                    if (getHouPactList.size()>0){//签约时当前房源有其他房源出租
                        if(HeZuCount==(1+getHouInfoNumList.size()+getHouPactList.size())){
                            result.putSuccess("新增合租非智能抄表数成功");
                        }else{
                            result.putFailed("新增合租非智能抄表数失败");
                        }

                    }else{//签约时当前房源无其他房间出租
                        if(HeZuCount==(1+getHouInfoNumList.size())){
                            result.putSuccess("新增合租非智能抄表数成功");
                        }else{
                            result.putFailed("新增合组非智能抄表数失败");
                        }

                    }

                }else{//合组智能
                    if(HeZuCount==0){
                        result.putSuccess("新增合租智能不需要抄表");
                    }else{
                        result.putFailed("新增合租非智能不抄表逻辑有误");
                    }

                }

            }

        } catch (NumberFormatException e) {
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();//事物回滚
        } finally {
            lock.unlock();//释放
        }

        return result;
    }

}


